home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / X11R4 / cmds / X / ddx / Xsun / diffs < prev    next >
Encoding:
Text File  |  1991-11-23  |  12.4 KB  |  440 lines
  1. *** /tmp/,RCSt1725321    Fri Nov 22 18:45:20 1991
  2. --- sunMouse.c    Sun Apr 22 23:36:35 1990
  3. ***************
  4. *** 73,79 ****
  5.   
  6.   static void           sunMouseCtrl();
  7.   static int           sunMouseGetMotionEvents();
  8. ! static Firm_event     *sunMouseGetEvents();
  9.   static void           sunMouseProcessEvent();
  10.   static void           sunMouseDoneEvents();
  11.   
  12. --- 73,79 ----
  13.   
  14.   static void           sunMouseCtrl();
  15.   static int           sunMouseGetMotionEvents();
  16. ! static Mouse_Event     *sunMouseGetEvents();
  17.   static void           sunMouseProcessEvent();
  18.   static void           sunMouseDoneEvents();
  19.   
  20. ***************
  21. *** 108,113 ****
  22. --- 108,116 ----
  23.    *    keyboard.  We have arbitrarily chosen to enable and disable windowFd
  24.    *    in the keyboard routine sunKbdProc rather than in sunMouseProc.
  25.    *
  26. +  *    In Sprite, things work like under suntools, in that /dev/mouse
  27. +  *    handles both mouse and keyboard.
  28. +  *
  29.    *-----------------------------------------------------------------------
  30.    */
  31.   int
  32. ***************
  33. *** 127,151 ****
  34.           return (!Success);
  35.           }
  36.   
  37. -         if (! sunUseSunWindows()) {
  38. -         if (sysMousePriv.fd >= 0) {
  39. -             fd = sysMousePriv.fd;
  40. -         } else {
  41. -             fd = open ("/dev/mouse", O_RDWR, 0);
  42. -             if (fd < 0) {
  43. -             Error ("Opening /dev/mouse");
  44. -             return (!Success);
  45. -             }
  46. -             if (fcntl (fd, F_SETFL, (FNDELAY|FASYNC)) < 0
  47. -             || fcntl(fd, F_SETOWN, getpid()) < 0) {
  48. -                 perror("sunMouseProc");
  49. -                 ErrorF("Can't set up mouse on fd %d\n", fd);
  50. -             }
  51. -             
  52. -             sysMousePriv.fd = fd;
  53. -         }
  54. -         }
  55. - 
  56.           sunMousePriv.bmask = 0;
  57.           sunMousePriv.mouseMoved = FALSE;
  58.           sysMousePriv.dx = 0;
  59. --- 130,135 ----
  60. ***************
  61. *** 161,198 ****
  62.           break;
  63.   
  64.       case DEVICE_ON:
  65. -         if (! sunUseSunWindows()) {
  66. -         if (ioctl (((PtrPrivPtr)pMouse->devicePrivate)->fd,
  67. -             VUIDGFORMAT, &oformat) < 0) {
  68. -             Error ("VUIDGFORMAT");
  69. -             return(!Success);
  70. -         }
  71. -         format = VUID_FIRM_EVENT;
  72. -         if (ioctl (((PtrPrivPtr)pMouse->devicePrivate)->fd,
  73. -             VUIDSFORMAT, &format) < 0) {
  74. -             Error ("VUIDSFORMAT");
  75. -             return(!Success);
  76. -         }
  77. -         AddEnabledDevice (((PtrPrivPtr)pMouse->devicePrivate)->fd);
  78. -         }
  79. - 
  80.           pMouse->on = TRUE;
  81.           break;
  82.   
  83.       case DEVICE_CLOSE:
  84. -         if (! sunUseSunWindows()) {
  85. -         if (ioctl (((PtrPrivPtr)pMouse->devicePrivate)->fd,
  86. -             VUIDSFORMAT, &oformat) < 0) {
  87. -             Error ("VUIDSFORMAT");
  88. -         }
  89. -         }
  90.           break;
  91.   
  92.       case DEVICE_OFF:
  93.           pMouse->on = FALSE;
  94. -         if (! sunUseSunWindows()) {
  95. -         RemoveEnabledDevice (((PtrPrivPtr)pMouse->devicePrivate)->fd);
  96. -         }
  97.           break;
  98.       }
  99.       return (Success);
  100. --- 145,158 ----
  101. ***************
  102. *** 250,256 ****
  103.    *    Return the events waiting in the wings for the given mouse.
  104.    *
  105.    * Results:
  106. !  *    A pointer to an array of Firm_events or (Firm_event *)0 if no events
  107.    *    The number of events contained in the array.
  108.    *    A boolean as to whether more events might be available.
  109.    *
  110. --- 210,216 ----
  111.    *    Return the events waiting in the wings for the given mouse.
  112.    *
  113.    * Results:
  114. !  *    A pointer to an array of Mouse_Events or (Mouse_Event *)0 if no events
  115.    *    The number of events contained in the array.
  116.    *    A boolean as to whether more events might be available.
  117.    *
  118. ***************
  119. *** 258,290 ****
  120.    *    None.
  121.    *-----------------------------------------------------------------------
  122.    */
  123. ! static Firm_event *
  124. ! sunMouseGetEvents (pMouse, pNumEvents, pAgain)
  125.       DevicePtr      pMouse;        /* Mouse to read */
  126.       int              *pNumEvents;        /* Place to return number of events */
  127. -     Bool      *pAgain;        /* whether more might be available */
  128.   {
  129. !     int              nBytes;        /* number of bytes of events available. */
  130. !     register PtrPrivPtr      pPriv;
  131. !     static Firm_event    evBuf[MAXEVENTS];   /* Buffer for Firm_events */
  132. ! 
  133. !     pPriv = (PtrPrivPtr) pMouse->devicePrivate;
  134. ! 
  135. !     nBytes = read (pPriv->fd, evBuf, sizeof(evBuf));
  136. ! 
  137. !     if (nBytes < 0) {
  138. !     if (errno == EWOULDBLOCK) {
  139. !         *pNumEvents = 0;
  140. !         *pAgain = FALSE;
  141. !     } else {
  142. !         Error ("Reading mouse");
  143. !         FatalError ("Could not read from mouse");
  144. !     }
  145. !     } else {
  146. !     *pNumEvents = nBytes / sizeof (Firm_event);
  147. !     *pAgain = (nBytes == sizeof (evBuf));
  148. !     }
  149. !     return (evBuf);
  150.   }
  151.   
  152.   
  153. --- 218,229 ----
  154.    *    None.
  155.    *-----------------------------------------------------------------------
  156.    */
  157. ! static Mouse_Event *
  158. ! sunMouseGetEvents (pMouse, pNumEvents)
  159.       DevicePtr      pMouse;        /* Mouse to read */
  160.       int              *pNumEvents;        /* Place to return number of events */
  161.   {
  162. !     return (Mouse_Event *)0;
  163.   }
  164.   
  165.   
  166. ***************
  167. *** 336,399 ****
  168.    *-----------------------------------------------------------------------
  169.    */
  170.   static void
  171. ! sunMouseProcessEvent (pMouse, fe)
  172.       DevicePtr      pMouse;       /* Mouse from which the event came */
  173. !     Firm_event      *fe;            /* Event to process */
  174.   {
  175.       xEvent        xE;
  176.       register PtrPrivPtr    pPriv;    /* Private data for pointer */
  177.       register SunMsPrivPtr pSunPriv; /* Private data for mouse */
  178.       register int      bmask;    /* Temporary button mask */
  179.   
  180.       pPriv = (PtrPrivPtr)pMouse->devicePrivate;
  181.       pSunPriv = (SunMsPrivPtr) pPriv->devPrivate;
  182.   
  183. !     xE.u.keyButtonPointer.time = TVTOMILLI(fe->time);
  184. ! 
  185. !     switch (fe->id)
  186. !     {
  187. !     case MS_LEFT:
  188. !     case MS_MIDDLE:
  189. !     case MS_RIGHT:
  190. !     /*
  191. !      * A button changed state. Sometimes we will get two events
  192. !      * for a single state change. Should we get a button event which
  193. !      * reflects the current state of affairs, that event is discarded.
  194. !      *
  195. !      * Mouse buttons start at 1.
  196. !      */
  197. !     xE.u.u.detail = (fe->id - MS_LEFT) + 1;
  198. !     bmask = 1 << xE.u.u.detail;
  199. !     if (fe->value == VKEY_UP) {
  200. !         if (pSunPriv->bmask & bmask) {
  201. !         xE.u.u.type = ButtonRelease;
  202. !         pSunPriv->bmask &= ~bmask;
  203. !         } else {
  204. !         return;
  205. !         }
  206. !     } else {
  207. !         if ((pSunPriv->bmask & bmask) == 0) {
  208. !         xE.u.u.type = ButtonPress;
  209. !         pSunPriv->bmask |= bmask;
  210. !         } else {
  211. !         return;
  212. !         }
  213. !     }
  214. !     /*
  215. !      * If the mouse has moved, we must update any interested client
  216. !      * as well as DIX before sending a button event along.
  217. !      */
  218. !     if (pSunPriv->mouseMoved) {
  219. !         sunMouseDoneEvents (pMouse, FALSE);
  220. !     }
  221.       
  222. -     miPointerPosition (screenInfo.screens[0],
  223. -                &xE.u.keyButtonPointer.rootX,
  224. -                &xE.u.keyButtonPointer.rootY);
  225. -     
  226. -     (* pMouse->processInputProc) (&xE, pMouse, 1);
  227. -     break;
  228. -     case LOC_X_DELTA:
  229.       /*
  230.        * When we detect a change in the mouse coordinates, we call
  231.        * the cursor module to move the cursor. It has the option of
  232. --- 275,296 ----
  233.    *-----------------------------------------------------------------------
  234.    */
  235.   static void
  236. ! sunMouseProcessEvent (pMouse, ev)
  237.       DevicePtr      pMouse;       /* Mouse from which the event came */
  238. !     Mouse_Event      *ev;            /* Event to process */
  239.   {
  240.       xEvent        xE;
  241.       register PtrPrivPtr    pPriv;    /* Private data for pointer */
  242.       register SunMsPrivPtr pSunPriv; /* Private data for mouse */
  243.       register int      bmask;    /* Temporary button mask */
  244. +     register int      button;
  245.   
  246.       pPriv = (PtrPrivPtr)pMouse->devicePrivate;
  247.       pSunPriv = (SunMsPrivPtr) pPriv->devPrivate;
  248.   
  249. !     xE.u.keyButtonPointer.time = ev->time;
  250. !     bmask = ev->key ^ pSunPriv->bmask;
  251.   
  252.       /*
  253.        * When we detect a change in the mouse coordinates, we call
  254.        * the cursor module to move the cursor. It has the option of
  255. ***************
  256. *** 403,438 ****
  257.        * What should be done if it goes off the screen? Move to another
  258.        * screen? For now, we just force the pointer to stay on the
  259.        * screen...
  260. !      */
  261. !     pPriv->dx += MouseAccelerate (pMouse, fe->value);
  262. ! 
  263. ! #ifdef    SUN_ALL_MOTION
  264. !     miPointerDeltaCursor (screenInfo.screens[0], pPriv->dx, pPriv->dy, TRUE);
  265. !     pPriv->dx = 0;
  266. !     pPriv->dy = 0;
  267. ! #else
  268. !     ((SunMsPrivPtr)pPriv->devPrivate)->mouseMoved = TRUE;
  269. ! #endif
  270. !     break;
  271. !     case LOC_Y_DELTA:
  272. !     /*
  273.        * For some reason, motion up generates a positive y delta
  274.        * and motion down a negative delta, so we must subtract
  275.        * here instead of add...
  276.        */
  277. !     pPriv->dy -= MouseAccelerate (pMouse, fe->value);
  278. ! #ifdef SUN_ALL_MOTION
  279. !     miPointerDeltaCursor (screenInfo.screens[0], pPriv->dx, pPriv->dy, TRUE);
  280. !     pPriv->dx = 0;
  281. !     pPriv->dy = 0;
  282. ! #else
  283.       ((SunMsPrivPtr)pPriv->devPrivate)->mouseMoved = TRUE;
  284. ! #endif SUN_ALL_MOTION
  285. !     break;
  286. !     default:
  287. !     FatalError ("sunMouseProcessEvent: unrecognized id\n");
  288. !     break;
  289.       }
  290.   }
  291.   
  292.   /*ARGSUSED*/
  293. --- 300,339 ----
  294.        * What should be done if it goes off the screen? Move to another
  295.        * screen? For now, we just force the pointer to stay on the
  296.        * screen...
  297. !      *
  298.        * For some reason, motion up generates a positive y delta
  299.        * and motion down a negative delta, so we must subtract
  300.        * here instead of add...
  301.        */
  302. !     if (ev->deltaX) {
  303. !         pPriv->dx += MouseAccelerate (pMouse, ev->deltaX);
  304.           ((SunMsPrivPtr)pPriv->devPrivate)->mouseMoved = TRUE;
  305. !     }
  306. ! 
  307. !     if (ev->deltaY) {
  308. !         pPriv->dy -= MouseAccelerate (pMouse, ev->deltaY);
  309. !         ((SunMsPrivPtr)pPriv->devPrivate)->mouseMoved = TRUE;
  310. !     }
  311. ! 
  312. !     if (ev->key ^ pSunPriv->bmask) {
  313. !     sunMouseDoneEvents (pMouse, FALSE);
  314. !     }
  315. ! 
  316. !     xE.u.keyButtonPointer.time = ev->time;
  317. !     for (bmask = 4, button = 1; bmask != 0; bmask >>= 1, button++) {
  318. !     if ((ev->key & bmask) != (pSunPriv->bmask & bmask)) {
  319. !         xE.u.u.type = (ev->key & bmask) ? ButtonRelease : ButtonPress;
  320. !         xE.u.u.detail = button;
  321. ! 
  322. !         miPointerPosition (screenInfo.screens[0],
  323. !         &xE.u.keyButtonPointer.rootX,
  324. !         &xE.u.keyButtonPointer.rootY);
  325. ! 
  326. !         (* pMouse->processInputProc) (&xE, pMouse, 1);
  327. !     }
  328.       }
  329. +     pSunPriv->bmask = ev->key;
  330. +     lastEventTime = ev->time;
  331.   }
  332.   
  333.   /*ARGSUSED*/
  334. ***************
  335. *** 483,489 ****
  336.       ScreenPtr    pScreen;
  337.       Bool    entering;
  338.   {
  339. !     u_char  select;
  340.   
  341.       select = 1;
  342.       if (entering)
  343. --- 384,390 ----
  344.       ScreenPtr    pScreen;
  345.       Bool    entering;
  346.   {
  347. !     unsigned char  select;
  348.   
  349.       select = 1;
  350.       if (entering)
  351. ***************
  352. *** 530,615 ****
  353.       miPointerDeltaCursor (screenInfo.screens[0], dx, dy, TRUE);
  354.       }
  355.   }
  356. - 
  357. - #ifdef SUN_WINDOWS
  358. - 
  359. - /*
  360. -  * Process a sunwindows mouse event.  The possible events are
  361. -  *   LOC_MOVE
  362. -  *   MS_LEFT
  363. -  *   MS_MIDDLE
  364. -  *   MS_RIGHT
  365. -  */
  366. - 
  367. - void
  368. - sunMouseProcessEventSunWin(pMouse,se)
  369. -     DeviceRec *pMouse;
  370. -     register struct inputevent *se;
  371. - {   
  372. -     xEvent            xE;
  373. -     register int          bmask;    /* Temporary button mask */
  374. -     register PtrPrivPtr        pPriv;    /* Private data for pointer */
  375. -     register SunMsPrivPtr    pSunPriv; /* Private data for mouse */
  376. -     short            x, y;
  377. - 
  378. -     pPriv = (PtrPrivPtr)pMouse->devicePrivate;
  379. - 
  380. -     switch (event_id(se)) {
  381. -         case MS_LEFT:
  382. -         case MS_MIDDLE:
  383. -         case MS_RIGHT:
  384. -         /*
  385. -          * A button changed state. Sometimes we will get two events
  386. -          * for a single state change. Should we get a button event which
  387. -          * reflects the current state of affairs, that event is discarded.
  388. -          *
  389. -          * Mouse buttons start at 1.
  390. -          */
  391. -         pSunPriv = (SunMsPrivPtr) pPriv->devPrivate;
  392. -         xE.u.keyButtonPointer.time = TVTOMILLI(event_time(se));
  393. -         xE.u.u.detail = (event_id(se) - MS_LEFT) + 1;
  394. -         bmask = 1 << xE.u.u.detail;
  395. -         if (win_inputnegevent(se)) {
  396. -         if (pSunPriv->bmask & bmask) {
  397. -             xE.u.u.type = ButtonRelease;
  398. -             pSunPriv->bmask &= ~bmask;
  399. -         } else {
  400. -             return;
  401. -         }
  402. -         } else {
  403. -         if ((pSunPriv->bmask & bmask) == 0) {
  404. -             xE.u.u.type = ButtonPress;
  405. -             pSunPriv->bmask |= bmask;
  406. -         } else {
  407. -             return;
  408. -         }
  409. -         }
  410. -         miPointerPosition (screenInfo.screens[0],
  411. -             &xE.u.keyButtonPointer.rootX, &xE.u.keyButtonPointer.rootY);
  412. -             (* pMouse->processInputProc) (&xE, pMouse, 1);
  413. -             break;
  414. -         case LOC_MOVE:
  415. -         /*
  416. -          * Tell mi to go ahead and generate the event.
  417. -          */
  418. -         miPointerMoveCursor(screenInfo.screens[0], event_x(se),
  419. -         event_y(se), TRUE);
  420. - 
  421. -         /*
  422. -          * Find out if the mouse got constrained. If it did
  423. -          * then we have to tell SunWindows about it.
  424. -          */
  425. -         miPointerPosition (screenInfo.screens[0], &x, &y);
  426. -         if (x != event_x(se) || y != event_y(se))
  427. -             /*
  428. -                  * Tell SunWindows that X is constraining the mouse
  429. -                  * cursor so that the server and SunWindows stay in sync.
  430. -              */
  431. -             win_setmouseposition(windowFd, x, y);
  432. -         break;
  433. -     default:
  434. -         FatalError ("sunMouseProcessEventSunWin: unrecognized id\n");
  435. -         break;
  436. -     }
  437. - }
  438. - #endif SUN_WINDOWS
  439. --- 431,433 ----
  440.